//字典管理
export type dictionaryType = {
    fields: Item[],
    values: dictionaryValues,
    options: dictionaryOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: any[],
    rules: dictionaryRules,
    model: dictionaryModel,
    tableShow: boolean
}
type Item = {
    label?: string | unknown,
    prop: string | unknown,
    placeholder?: string | unknown,
    type?: string | unknown,
    bindLabel?: string | unknown,
    bindValue?: string | unknown,
    row?: number | unknown,
    disabled?: boolean | unknown,
}
type dictionaryValues = {
    name: string,
    deleted: number | string,
    orderBy: string,
    orderItemList: orderItemList
}
type orderItemList = {
    column: string,
    asc: boolean
}
type dictionaryOptions = {
    deleted: statusItem[]
}
type statusItem = {
    name: string,
    id: string | number
}
type tableItem = {
    label: string,
    prop: string,
    isOrderBy?: boolean | unknown,
    screen?: boolean | unknown
}
type dictionaryRules = {
    name: rule[],
    value: rule[],
}
type rule = {
    required?: boolean | null | unknown,
    message?: string,
    trigger?: string | null | unknown,
    pattern?: any | null | unknown

}
type dictionaryModel = {
    id: number,
    name: string,
    value: string,
    remark: string
}
//字典管理-数据字典
export type dictionaryChildType = {
    fields: Item[],
    values: dictionaryChildValues,
    options: dictionaryChildOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: dictionaryChildRules,
    model: dictionaryChildModel,
    tableShow: boolean
}
type dictionaryChildValues = {
    name: string,
    deleted: number | string,
    parent: string | null
}
type dictionaryChildOptions = {
    deleted: statusItem[],
    sortBy: statusItem[]
}
type dictionaryChildRules = {
    name: rule[],
    value: rule[],
}
type dictionaryChildModel = {
    id: number,
    name: string,
    value: string,
    remark: string,
    parent: string,
    sortBy: string
}
//消息模版
export type messageType = {
    fields: Item[],
    values: messageValues,
    options: messageOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: messageRules,
    model: messageModel,
    formTbaleFields: tableItem[]
}
type messageValues = {
    name: string,
}
type messageOptions = {
    notifyCategory: statusItem[]
}
type messageRules = {
    name: rule[],
    content: rule[],
}
type messageModel = {
    id: string | number,
    name: string,
    sendTime: string,
    content: string,
    notifyCategory: string,
    empList: empItem[],
    emp: string
}
type empItem = {
    empId: string,
    name: string,
    email: string
}
//文件模版管理
export type fileType = {
    fields: Item[],
    values: fileValues,
    options: fileOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: fileRules,
    model: fileModel,
    fileList: fileListType[],
    action: string,
    headers: headerItem
}
type fileValues = {
    name: string,
    category: string
}
type fileOptions = {
    category: statusItem[]
}
type fileRules = {
    category: rule[],
    name: rule[],
    url: rule[]
}
type fileModel = {
    id: number,
    name: string,
    url: string,
    category: string,
    remark: string,
}
type fileListType = {
    name: string,
    url: string
}
type headerItem = {
    token: any
}
//权限管理-部门管理
export type authorityDeptType = {
    fields: Item[],
    values: authorityDeptValues,
    options: authorityDeptOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: authorityDeptRules,
    model: authorityDeptModel,
}
type authorityDeptValues = {
    name: string,
    deleted: string | null,
}
type authorityDeptOptions = {
    deleted: statusItem[]
}
type authorityDeptRules = {
    name: rule[],
    shortName: rule[]
}
type authorityDeptModel = {
    name: string,
    shortName: string,
    isBiz: number | string,
    deleted: number,
    id: number,
    status: string | number
}
//权限管理-用户管理
export type authorityAccountType = {
    fields: Item[],
    values: authorityAccountValues,
    options: authorityAccountOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: authorityAccountRules,
    model: authorityAccountModel,
    dept: statusItem[],
    detailShow: boolean,
    deptName: string,
    array: statusItem[],
    isBiz: number | string
}
type authorityAccountValues = {
    findKey: string,
    status: string,
    deptId: number | null | string,
    roleId: number | null | string
}
type authorityAccountOptions = {
    status: statusItem[],
    deptId: statusItem[],
    roleId: roleIdItem[],
    usetTag: statusItem[]
}
type roleIdItem = {
    roleName: string,
    id: string,
    roleCode: string
}
type authorityAccountRules = {
    name: rule[],
    mobile: rule[],
    email: rule[],
    deptId: rule[],
}
type authorityAccountModel = {
    id: string,
    mobile: string,
    name: string,
    status: number,
    email: string,
    deptId: string | number,
    otherDeptIds: number[] | string[],
    tagIds: number[] | string[],
    empRoleIds: number[] | string[],
}
//权限管理-菜单管理
export type authorityMenuType = {
    dataSource: treeItem[],
    props: propsItem,
    fields: Item[],
    show: boolean,
    title: string,
    model: authorityMenuModel,
    rules: authorityMenuRules,
    options: authorityMenuOptions,
   
}
type treeItem = {
    children: treeItem[],
    id: string | number,
    parentId: string | number,
    name: string,
    sysLabel: sysItem,
    permCode: string,
    idxUri: string,
    classify: number
}
type sysItem = {
    desc: string,
    value: number
}
type propsItem = {
    label: string,
    children: string
}
type authorityMenuModel = {
    id: number,
    parentId: number | string | null,
    name: string,
    classify: string,
    idxUri: string,
    permCode: string,
    sysLabel: string,
    parentName: string,
    tab: string,
    icon:string,
}
type authorityMenuRules = {
    name: rule[],
    idxUri: rule[],
    permCode: rule[]
}
type authorityMenuOptions = {
    classify: classifyItem[],
    sysLabel: classifyItem[]
}
type classifyItem = {
    label: string,
    value: string
}
//权限管理-角色管理
export type authorityRoleType = {
    fields: Item[],
    values: authorityRoleValues,
    options: authorityRoleOptions,
    tableFields: tableItem[],
}
type authorityRoleValues = {
    roleName: string,
    deleted: string | null,
}
type authorityRoleOptions = {
    deleted: statusItem[]
}
//权限管理-角色管理-添加编辑
export type authorityRoleAddType = {
    addFields: Item[],
    rules: authorityRoleAddRules,
    model: authorityRoleAddModel,
    props: propsItem,
    sysData: any,
    statData: any,
    businessData: any,
    noticeList: noticeItem[],
}
type authorityRoleAddRules = {
    roleName: rule[],
}
type authorityRoleAddModel = {
    roleName: string,
    roleNoticeIds: number[],
    status: number,
    statisticsList: number[],
    businessList: number[],
    srcList: number[],
    id: number | string,
    roleCode: string | null
}
type noticeItem = {
    name: string,
    id: string | number,
    value: string
}
//流程管理-表单信息
export type flowPathFormType = {
    show: boolean,
    model: flowPathFormModel,
    editFields: Item[],
    fields: Item[],
    values: flowPathFormValues,
    tableFields: Item[],
    transfer: any,
    arrList: any,
    title: string,
    rules: flowPathFormRules,
    props: flowPathFormProps
}
type flowPathFormModel = {
    id: number | string,
    name: string,
    formIds: string[],
    ids: string[],
    remark: string,
}
type flowPathFormValues = {
    name: string,
}
type flowPathFormRules = {
    name: rule[],
    ids: rule[],
}
type flowPathFormProps = {
    label: string,
    key: string
}
//流程管理-节点管理
export type flowPathNodeType = {
    fields: Item[],
    values: flowPathNodeValues,
    tableFields: Item[]
}
type flowPathNodeValues = {
    name: string
}
//流程管理-流程管理
export type flowPathFlowType = {
    fields: Item[],
    values: flowPathFlowValues,
    tableFields: Item[],
    copyShow: boolean,
    copyTitle: string,
    model: flowPathFlowModel,
    loading: boolean,
}
type flowPathFlowValues = {
    name: string,
}
type flowPathFlowModel = {
    id: string | number,
    name: string,
}
//流程管理-流程管理-新建流程
export type flowPathFlowAddType = {
    scale: number,
    name: string,
}
//流程管理-流程管理-新建流程
export type flowPathFlowEditType = {
    scale: number,
    name: string,
    designData: string | null,
    loading: boolean,
    status: number
}
//流程管理-小表单管理
export type flowPathChildFormType = {
    fields: Item[],
    values: flowPathChildFormValues,
    tableFields: Item[]
}
type flowPathChildFormValues = {
    name: string,
}

//流程管理-小表单管理-新建编辑表单
export type flowPathChildFormAddType = {
    fields: Item[],
    values: flowPathChildFormAddValues,
    options: any,
    show: boolean,
    title: string,
    addFields: Item[],
    rules: flowPathChildFormAddRules,
    model: flowPathChildFormAddModel,
    tableFields: Item[],
    detailShow: boolean,
    index: number,
    tableRecords?: Item[]
}
type flowPathChildFormAddValues = {
    name: string,
    status: string | number,
    id: number | string,
    formStruct: formStruct,
    category: string | number,
    tagName: string,
    subTitle: string,
    bindName?: string,
}
type formStruct = {
    formFields: any,
    formModel: any,
    formRules: any
}
type flowPathChildFormAddRules = {
    type: rule[],
    label: rule[],
    name: rule[],
}
type flowPathChildFormAddModel = {
    label: string,
    type: string,
    prop: string,
    placeholder: string,
    unit: string,
    message: string,
    sort: string | number,
    id: string | number,
}
//流程管理-小表单管理-表单详情
export type flowPathChildFormDetailType={
    type:string,
    records:records[],
    unitId:string|number,
}
type records={
    tag:string,
    isEnabled:number,
    code?:string
}
//担保公司管理
export type companyType = {
    fields: Item[],
    values: companyValues,
    options: companyOptions,
    tableFields: Item[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: companyRules,
    model: companyModel,
    tag:false,
}
type companyValues = {
    usci: string,
    name: string,
    status: string
}
type companyOptions = {
    status: statusItem[],
    roleCode: roleCodeItem[]
}
type roleCodeItem = {
    roleCode: string,
    roleName: string
}
type companyRules = {
    usci: rule[],
    name: rule[],
    empName: rule[],
    empMobile: rule[],
    empEmail: rule[],
    roleCode: rule[],
}
type companyModel = {
    usci: string,
    name: string,
    empName: string,
    empMobile: string,
    empEmail: string,
    roleCode: string,
    findEmpMobile: string,
    id: number | string | null
}
//产品管理
export type productType = {
    fields: Item[],
    values: productValues,
    options: productOptions,
    tableFields: tableItem[],
    show: boolean,
    title: string,
    addFields: Item[],
    rules: productRules,
    model: productModel,
    copyShow: boolean,
    copyTitle: string,
    logValues: log
}
type productValues = {
    name: string,
    category: string,
    status: string | number,
}
type productOptions = {
    category: statusItem[],
    status: statusItem[],
    flowId?: statusItem[]
}
type productRules = {
    name: rule[],
    category: rule[],
    flowId: rule[],
}
type productModel = {
    id: number | string,
    name: string,
    category: string,
    flowId: number | string,
    status: number | string
}
type log = {
    bizId: string | number,
    category: string,
}
//产品管理-回收站
export type productRecycleBinType = {
    fields: Item[],
    values: productValues,
    options: productOptions,
    tableFields: tableItem[],
    selection: string[] | number[],
    logValues: log
}
//合作机构
export type institutionType = {
    fields: Item[],
    values: institutionValues,
    options: institutionOption,
    tableFields: tableItem[],
    bankShow: boolean,
    bankTitle: string,
    bankFields: Item[],
    limitShow: boolean,
    limitFields: Item[],
    logValues: log,
    bankVal: val
}
type institutionValues = {
    productId: string | number,
    name: string,
}
type institutionOption = {
    productId: statusItem[]
}
type val = {
    id: string | number
}
//合作机构-新建编辑机构
export type institutionAddType = {
    [key: string]: any,
    fields: Item[],
    props: propType,
    districts: districtsType[]
    options: institutionAddOption,
    model: institutionAddModel,
    arr1: arr[],
    arr2: arr[],
    arr3: arr[],
    arr4: arr[],
    checkList1: string[] | number[],
    checkList2: string[] | number[],
    checkList3: string[] | number[],
    checkList4: string[] | number[],
    area: any,
    bankProps: propType,
    checkArr1: arr[],
    checkArr2: arr[],
    checkArr3: arr[],
    checkArr4: arr[],
    dialogVisible: boolean,
    name: string,
    index: number,
    index1: number,
    action: string,
    headers: headerItem,
    fileList: fileItem[],
    rules: institutionAddRules
}
type fileItem = {
    name: string,
    url: string
}
type arr = {
    name: string,
    id: number | string,
    children: childItem[]
}
type childItem = {
    agencyId: number | string,
    productId: number | string,
    name: string,
    beginDate: string,
    finishDate: string,
    amountLimit: string,
    spendingLimit: string,
    balanceLimit: string,
    liability: string,
    cooperationDoc: string,
    file: string[],
    lockMoney:string,
}
type propType= {
    multiple: boolean,
    value: string,
    label: string,
    children: string
}
type districtsType ={
    name: string,
    level: string,
    adcode: string,
    districts?: districtsType[]
}
type institutionAddOption={
    status: statusItem[]
}
type institutionAddModel={
    name: string,
    shortName: string,
    status: string,
    area: string[],
    project: any,
    branch: branch[],
    id: number | string
}
type branch ={
    agencyId: number | string,
    name: string,
    area: string[],
}
type institutionAddRules={
    name: rule[],
    shortName: rule[],
    status: rule[],
    area: rule[],
}